#ifdef __PC__
  #include "commonArduino.h"
#endif


#include "menu.h"
#include "acciones.h"
#include "utilMenu.h"
#include "rtc.h"

#include "LiquidCrystal.h" // Librería para el LCD

#include <stdio.h>

#define TIMEOUT_MENU 5*1000 // milliseconds

//typedef struct typeMenu;


void printMainMenu( )
{
	// para depuracion
	//         01234567890123456789
	printf( "\n0---------0---------\n");
	printf( "MAIN MENU\n");
	printf( "opcionCalefaccion=");
	if( opcionCalefaccion == DESACTIVADA) {
		printf( "APAGADA\n");
	}
	else if( opcionCalefaccion == ACTIVADA) {
		printf( "ENCENDIDA\n");
	}
	else {
		printf( "PROGRAMADA\n");
	}

	printf( "calefaccionEncendida=%s\n", calefaccionEncendida?"true":"false");
	printf( "programaCalefaccion.temperatura=%0dºC\n", programaCalefaccion.temperatura);
	printf( "programaCalefaccion.inicio=%02d:%02d\n", programaCalefaccion.inicio/60, programaCalefaccion.inicio%60);
	printf( "programaCalefaccion.fin=%02d:%02d\n", programaCalefaccion.fin/60, programaCalefaccion.fin%60);
	printf( "inversorEncendido=%s\n", inversorEncendido?"true":"false");
	char* str = getTimeHHMM();
	int currentTemp = readTemperature();
	printf( "Hora=%2.2s:%2.2s   Temp=%0dºC\n", str, str+2, currentTemp);
//	printf( "(opcionCalefaccion=%d\n", opcionCalefaccion);

/*
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.write(1);
    if (vB1 < 10.00) {
        lcd.print(" ");}
        lcd.print(vB1);
        lcd.setCursor(5,0);
           lcd.print("v ");

        // Escribir la hora
          Wire.beginTransmission(DS1307_I2C_ADDRESS);
        Wire.write(zero);
        Wire.endTransmission();

        Wire.requestFrom(DS1307_I2C_ADDRESS, 7);
        second     = bcdToDec(Wire.read() & 0x7f);    // Lee secuencialmente, si no se leen los segundos toma mal los valores de hora y minuto
        minute     = bcdToDec(Wire.read());
        hour       = bcdToDec(Wire.read() & 0x3f);  // Need to change this if 12 hour am/pm

        if (hour < 10)
            lcd.print("0");
               lcd.print(hour, DEC);
               lcd.print(":");
               if (minute < 10)
                lcd.print("0");
           lcd.print(minute, DEC);
           //lcd.print("23:35");    EJEMPLO
           // Escribir la hora END

           if (simbAlt){
               lcd.setCursor(13,0);
               lcd.write(3);}
           if (simb220){
               lcd.setCursor(14,0);
               lcd.write(4);}
               else{
                   if(simbInv){
                       lcd.setCursor(14,0);
                       lcd.write(5);}}
           if (simbSol){
               lcd.setCursor(15,0);
               lcd.write(6);}
           lcd.setCursor(0,1);        // segunda linea
           lcd.write(2);
           if (vB2 < 10.00) {
               lcd.print(" ");}
           lcd.print(vB2);
           lcd.setCursor(5,1);
           lcd.print("v ");
           //escribir el amperaje
           if ((aB2 >= 0.00)||(aB2 < 10.00)){
               lcd.print(" ");}
           lcd.print(aB2);
           lcd.print("A");
           if(simbCal){
               lcd.setCursor(14,1);
               lcd.write(7);}
           if(simbLuc){
               lcd.setCursor(15,1);
               lcd.write(8);}
*/
	//printf( "--------------------\nMAIN\nMENU\n");
}

void printMenuGeneric( const char* line1, const char* line2)
{
    lcd.clear();
    lcd.print( line1);
    lcd.setCursor( 0,1);
    lcd.print( line2);
//    printf( "--------------------\n%s\n%s\n", line1, line2);
}

void printMenuConmutarCalefaccion( const char* line1, const char* dummy)
{
	const char* line2 = "Encender  ???  >";

	if( calefaccionEncendida) {
		line2 = "Apagar    ???  >";
	}
	printMenuGeneric( line1, line2);
}



static bool esperandoConfirmacion = false;
static bool esperandoCancelacion = false;
static bool mensajeError = false;


void processKeyCalefaccionProgramar( const char ch)
{
	switch( ch) {
	  case KEY_INITIALIZE:
		  mensajeError = false;
		  setBuffer( " t:20c 20:00-23:00 ");
		  getFirstDigit();
		  return;
	  case KEY_BACKWARD:
		  if( esperandoCancelacion) {
			  esperandoCancelacion = false;
			  //currentDigit = 0;
			  menu.moveBackward();
		  }
		  else {
			  if( esperandoConfirmacion) {
				  esperandoConfirmacion = false;
				  //menu.moveBackward();
			  }
			  if( getPreviousDigit() == BUFFER_DELIMITER) {
				  esperandoCancelacion = true;
				  mensajeError = false;
			  }
		  }
		  break;
	  case KEY_FORWARD:
		  if( !esperandoConfirmacion) {
			  if( esperandoCancelacion) {
				  esperandoCancelacion = false;
			  }
			  if( getNextDigit() == BUFFER_DELIMITER) {
				  if( !mensajeError) {
					  esperandoConfirmacion = true;
				  }
				  else {
					  getPreviousDigit();
				  }
			  }
//			  if( currentDigit == 2) { // el separador de campos
//				  currentDigit++;
//			  }
		  }
		  break;
	  case KEY_UPWARD:
	    //printf("buffer[currentDigit]=%d\n", buffer[currentDigit]);
	      if( !esperandoConfirmacion && !esperandoCancelacion) {
	    	  incDigit();
	      }
		  mensajeError = !programarCalefaccion( getBuffer());

		  break;
	  case KEY_DOWNWARD:
	    //printf("buffer[currentDigit]=%d\n", buffer[currentDigit]);
	      if( !esperandoConfirmacion && !esperandoCancelacion) {
	    	  decDigit();
	      }
		  mensajeError = !programarCalefaccion( getBuffer());
		  break;
	  case KEY_ACTION:
		  if( esperandoConfirmacion && !mensajeError) {
			  esperandoConfirmacion = false;
//			  if( programarCalefaccion( getBuffer()) ) {
				  //menu.doAction();
				  opcionCalefaccion = PROGRAMADA;
				  menu.reset();
//			  }
//			  else {
//				  mensajeError = "ERROR!";
//			  }
		  }
		  break;
	}
    //printf("currentIndex=%d\n", getCurrentIndex());
}

void printInputScreen( const char* line1, const char* dummy)
{
	// "01234567890123456789"
	// "Calefac.            "
	// "Calefac.         OK?"
	// "Calefac.     CANCEL?"
	// "Calefac.      ERROR!"
	// "  [ 00:00 - 00:00 ] "
    lcd.clear();
    lcd.print( line1);
    lcd.setCursor( 1, 10);
    // fprintf(&lcdout,
    lcd.print( getBuffer()+1);
    if( mensajeError) {
    	lcd.setCursor( 0, 14);
    	lcd.print( "ERROR!");
    }
    else if( esperandoConfirmacion) {
    	lcd.setCursor( 0, 17);
    	lcd.print( "OK?");
    }
    else if( esperandoCancelacion) {
    	lcd.setCursor( 0, 13);
    	lcd.print( "CANCEL?");
    }
    else {
    	lcd.setCursor( 1, 0);
    	lcd.print( getBuffer());
    	lcd.setCursor( 1, getCurrentIndex());
    	lcd.blink();
    }
    //printf("currentIndex(2)=%d\n", getCurrentIndex());
}

void processKeyCalefaccionProgramar2( const char ch)
{
	switch( ch) {
	  case KEY_INITIALIZE:
		  mensajeError = false;
		  //		  setBuffer( "  [ 21:00 - 23:00 ] ");
		  sprintf( getBuffer(), "  [ %02d:%02d - %02d:%02d ] ",
				  programaCalefaccion.inicio/60,
				  programaCalefaccion.inicio%60,
				  programaCalefaccion.fin/60,
				  programaCalefaccion.fin%60);
		  getFirstDigit();
		  return;
	  case KEY_BACKWARD:
		  if( esperandoCancelacion) {
			  esperandoCancelacion = false;
			  //currentDigit = 0;
			  menu.moveBackward();
		  }
		  else {
			  if( esperandoConfirmacion) {
				  esperandoConfirmacion = false;
				  //menu.moveBackward();
			  }
			  if( getPreviousDigit() == BUFFER_DELIMITER) {
				  esperandoCancelacion = true;
				  mensajeError = false;
			  }
		  }
		  break;
	  case KEY_FORWARD:
		  if( !esperandoConfirmacion) {
			  if( esperandoCancelacion) {
				  esperandoCancelacion = false;
			  }
			  if( getNextDigit() == BUFFER_DELIMITER) {
				  if( !mensajeError) {
					  esperandoConfirmacion = true;
				  }
				  else {
					  getPreviousDigit();
				  }
			  }
//			  if( currentDigit == 2) { // el separador de campos
//				  currentDigit++;
//			  }
		  }
		  break;
	  case KEY_UPWARD:
	    //printf("buffer[currentDigit]=%d\n", buffer[currentDigit]);
	      if( !esperandoConfirmacion && !esperandoCancelacion) {
	    	  incDigit();
	      }
		  mensajeError = !programarCalefaccion2( getBuffer());

		  break;
	  case KEY_DOWNWARD:
	    //printf("buffer[currentDigit]=%d\n", buffer[currentDigit]);
	      if( !esperandoConfirmacion && !esperandoCancelacion) {
	    	  decDigit();
	      }
		  mensajeError = !programarCalefaccion2( getBuffer());
		  break;
	  case KEY_ACTION:
		  if( esperandoConfirmacion && !mensajeError) {
			  esperandoConfirmacion = false;
//			  if( programarCalefaccion( getBuffer()) ) {
				  //menu.doAction();
				  opcionCalefaccion = PROGRAMADA;
				  menu.reset();
//			  }
//			  else {
//				  mensajeError = "ERROR!";
//			  }
		  }
		  break;
	}
    //printf("currentIndex=%d\n", getCurrentIndex());
}

/*
void printCalefaccionTemperatura( const char* line1, const char* dummy)
{
	// "01234567890123456789"
	// "TEMP.CALEF.         "
	// "TEMP.CALEF.      OK?"
	// "TEMP.CALEF.  CANCEL?"
	// "TEMP.CALEF.   ERROR!"
	// "       00 ºC        "
    lcd.clear();
    lcd.print( line1);
    lcd.setCursor( 1, 10);
    // fprintf(&lcdout,
    lcd.print( getBuffer()+1);
    if( mensajeError) {
    	lcd.setCursor( 0, 14);
    	lcd.print( "ERROR!");
    }
    else if( esperandoConfirmacion) {
    	lcd.setCursor( 0, 17);
    	lcd.print( "OK?");
    }
    else if( esperandoCancelacion) {
    	lcd.setCursor( 0, 13);
    	lcd.print( "CANCEL?");
    }
    else {
    	lcd.setCursor( 1, 0);
    	lcd.print( getBuffer());
    	lcd.setCursor( 1, getCurrentIndex());
    	lcd.blink();
    }
    printf("currentIndex(2)=%d\n", getCurrentIndex());
}
*/
void processKeyCalefaccionTemperatura( const char ch)
{
	switch( ch) {
	  case KEY_INITIALIZE:
		  mensajeError = false;
//		  setBuffer( "       00 ºC        ");
		  sprintf( getBuffer(), "       %02d ºC        ", programaCalefaccion.temperatura);
		  getFirstDigit();
		  return;
	  case KEY_BACKWARD:
		  if( esperandoCancelacion) {
			  esperandoCancelacion = false;
			  //currentDigit = 0;
			  menu.moveBackward();
		  }
		  else {
			  if( esperandoConfirmacion) {
				  esperandoConfirmacion = false;
				  //menu.moveBackward();
			  }
			  if( getPreviousDigit() == BUFFER_DELIMITER) {
				  esperandoCancelacion = true;
				  mensajeError = false;
			  }
		  }
		  break;
	  case KEY_FORWARD:
		  if( !esperandoConfirmacion) {
			  if( esperandoCancelacion) {
				  esperandoCancelacion = false;
			  }
			  if( getNextDigit() == BUFFER_DELIMITER) {
				  if( !mensajeError) {
					  esperandoConfirmacion = true;
				  }
				  else {
					  getPreviousDigit();
				  }
			  }
//			  if( currentDigit == 2) { // el separador de campos
//				  currentDigit++;
//			  }
		  }
		  break;
	  case KEY_UPWARD:
	    //printf("buffer[currentDigit]=%d\n", buffer[currentDigit]);
	      if( !esperandoConfirmacion && !esperandoCancelacion) {
	    	  incDigit();
	      }
		  mensajeError = !setTemperaturaCalefaccion( getBuffer());

		  break;
	  case KEY_DOWNWARD:
	    //printf("buffer[currentDigit]=%d\n", buffer[currentDigit]);
	      if( !esperandoConfirmacion && !esperandoCancelacion) {
	    	  decDigit();
	      }
		  mensajeError = !setTemperaturaCalefaccion( getBuffer());
		  break;
	  case KEY_ACTION:
		  if( esperandoConfirmacion && !mensajeError) {
			  esperandoConfirmacion = false;
//			  if( programarCalefaccion( getBuffer()) ) {
				  //menu.doAction();
				  //opcionCalefaccion = PROGRAMADA;
				  menu.reset();
//			  }
//			  else {
//				  mensajeError = "ERROR!";
//			  }
		  }
		  break;
	}
    //printf("currentIndex=%d\n", getCurrentIndex());
}


void printMenuConmutarInversor( const char* line1, const char* dummy)
{
	const char* line2 = "Encender  ???  >";

	if( inversorEncendido) {
		line2 = "Apagar    ???  >";
	}
	printMenuGeneric( line1, line2);
}

void printMenuEncenderLuces( const char* line1, const char* dummy)
{
	const char* line2 = "Apagar    ???  >";

	if( estadoLuces == OFF) {
		line2 = "AUTO      ???  >";
	}
	else if( estadoLuces == AUTO) {
		line2 = "Encender  ???  >";
	}
	printMenuGeneric( line1, line2);
}
void printMenuEncenderPuertas( const char* line1, const char* dummy)
{
	const char* line2 = "Encender  ???  >";

	if( estadoPuertas) {
		line2 = "Apagar    ???  >";
	}
	printMenuGeneric( line1, line2);
}
void printMenuEncenderLDR( const char* line1, const char* dummy)
{
	const char* line2 = "Encender  ???  >";

	if( estadoLDR) {
		line2 = "Apagar    ???  >";
	}
	printMenuGeneric( line1, line2);
}





/*
 * 		Calefacción	(Item1)
			Temperatura (Sub1)
				Configurar temperatura
			Cronometro	(Sub2)
				Minutos para apagar
			Encender	(Sub3)
				Configurar hora
			Apagar		(Sub4)
				Configurar hora
 */

//const static Menu::MenuItem menuClefaccion_Temperatura[] = {
//	{ 0, "Temperatura", "* 18c     (OK) >", printGenericMenu, 0, NULL},
//	{ 0, "Temperatura", "* 20c     (OK) >", printGenericMenu, 0, NULL},
//	{ 0, "Temperatura", "* 22c     (OK) >", printGenericMenu, 0, NULL},
//	{ 0, "Temperatura", "* 24c     (OK) >", printGenericMenu, 0, NULL},
//	{ 0, "Temperatura", "* 26c     (OK) >", printGenericMenu, 0, NULL},
//	{ 0, "Temperatura", "* 28c     (OK) >", printGenericMenu, 0, NULL},
//	{ 1, "Temperatura", "* 30c     (OK) >", printGenericMenu, 0, NULL}
//};
const static Menu::MenuItem menuCalefaccionTemperatura[] = {
	//{ 0, "Calefaccion", "Apagar (OK)    >", printGenericMenu, &apagarCalefaccion, NULL},
		//01234567890123456789  //01234567890123456789
		//             CANCEL?
	{ 1, "TEMP.CAL.           ", NULL, printInputScreen, processKeyCalefaccionTemperatura, NULL, NULL}//(Menu::MenuItem (*)[])&menuClefaccion_Temperatura},
};
const static Menu::MenuItem menuCalefaccionProgramar[] = {
	//{ 0, "Calefaccion", "Apagar (OK)    >", printGenericMenu, &apagarCalefaccion, NULL},
		//01234567890123456789  //01234567890123456789
		//             CANCEL?
	{ 1, "PROG.CAL.           ", NULL, printInputScreen, processKeyCalefaccionProgramar2, NULL, NULL}//(Menu::MenuItem (*)[])&menuClefaccion_Temperatura},
};
const static Menu::MenuItem menuCalefaccion[] = {
	//{ 0, "Calefaccion", "Apagar (OK)    >", printGenericMenu, &apagarCalefaccion, NULL},
		//01234567890123456789
	{ 0, "ENCENDER CALEFACCION", "", printMenuGeneric, NULL, &encenderCalefaccion, NULL},
	{ 0, "APAGAR   CALEFACCION", "", printMenuGeneric, NULL, &apagarCalefaccion, NULL},
	{ 0, "TEMP.    CALEFACCION", "", printMenuGeneric, NULL, NULL, (Menu::MenuItem (*)[])&menuCalefaccionTemperatura},
	{ 1, "PROGRAM. CALEFACCION", "", printMenuGeneric, NULL, NULL, (Menu::MenuItem (*)[])&menuCalefaccionProgramar}//(Menu::MenuItem (*)[])&menuClefaccion_Temperatura},
};
/*
 * 		Inversor	(Item2)
			Encender	(Sub1)
			Apagar		(Sub2)
 */
const static Menu::MenuItem menuInversor[] = {
	//{ 0, "Inversor", "Encender (OK)  >", &printGenericMenu, &encenderInversor, NULL},
		//01234567890123456789
	{ 1, "INVERSOR            ", NULL, &printMenuConmutarInversor, NULL, &conmutarInversor, NULL}
};
/*
 * 		Iluminacion (Item3)
			Luces automáticas	(Sub1)
				Encender			(Sub11)
				Apagar
				Umbral Alto
				Umbral Bajo
				Retraso apagado
			LDR
				Encender
				Apagar
 *
 */
//const static Menu::MenuItem menuIluminacion[] = {
//	{ 0, "LUCES      ", NULL, &printMenuEncenderLuces, conmutarLuces, NULL},
//	{ 0, "LDR        ", NULL, &printMenuEncenderLDR, conmutarLDR, NULL},
//};


//const static Menu::MenuItem menuSeguridad_RFID[] = {
//	{ 0, "RFID", "Encender (OK)  >", &printGenericMenu, 0, NULL},
//	{ 1, "RFID", "Apagar (OK)    <", &printGenericMenu, 0, NULL}
//};
/*
 * 		Seguridad (Item4)
			Puertas
				Encender
				Apagar
			RFID
				Activar
				Desactivar (PIN)
			BIP
				Activar
				Desactivar
 */
//const static Menu::MenuItem menuSeguridad[] = {
//	{ 0, "Seguridad", NULL, &printMenuEncenderPuertas, 0, NULL},
//	{ 0, "Seguridad", "RFID (OK)      >", &printGenericMenu, 0, (Menu::MenuItem (*)[])&menuSeguridad_RFID},
//	{ 0, "Seguridad", "BIP (OK)       >", &printGenericMenu, 0, NULL},
//	{ 0, "Seguridad", "Encender (OK)  >", &printGenericMenu, 0, NULL},
//	{ 1, "Seguridad", "Apagar (OK)    <", &printGenericMenu, 0, NULL}
//};
Menu::MenuItem Menu::mainMenu[] = {
	{ 0, "", "", 0, NULL}, // Menú Base
	{ 0, "CALEFACCION", "            --->", &printMenuGeneric, NULL, NULL, (Menu::MenuItem (*)[])&menuCalefaccion},
//	{ 1, "INVERSOR",    "            --->", &printMenuGeneric, NULL, NULL, (Menu::MenuItem (*)[])&menuInversor},
	{ 1, "INVERSOR            ", NULL, &printMenuConmutarInversor, NULL, &conmutarInversor, NULL}
//	{ 0, "ILUMINACION", "            --->", &printMenuGeneric, 0, (Menu::MenuItem (*)[])&menuIluminacion},
//	{ 1, "SEGURIDAD",   "            --->", &printMenuGeneric, 0, (Menu::MenuItem (*)[])&menuSeguridad}
};

/*
 * Configuración
	Encendido del inversor
	Encendido del cargador ??
	Encendido de las luces diurnas
	Encendido de luces automático
	Encendido LED pantalla
	Umbral luces automáticas
	Encendido control de puertas
	Encendido pitido confirmacion
	Programador calefacción
 */
Menu::Menu()
{
	reset();
}
void Menu::reset()
{
	top = 0;
	currentMenu = (Menu::MenuItem (*)[])&mainMenu;
	idxCurrentMenu[top] = 0;
}

long timestampMenuPrinted = 0;

void Menu::print()
{
//    doMenu func = eduMenu[idxCurrentMenu].func;
//    if( func == NULL) {
//        func = &printGenericMenu;
//    }
//    func( eduMenu[idxCurrentMenu].line1, eduMenu[idxCurrentMenu].line2);
	if( (top == 0) && (idxCurrentMenu[top] == 0)) {
		printMainMenu();
	}
	else {
		tMenuItem *menuItem = &(*currentMenu)[idxCurrentMenu[top]];
		menuItem->print( menuItem->line1, menuItem->line2);
	}
	timestampMenuPrinted = millis();
	//printf( "top=%d\n", top);
}

void Menu::moveForward()
{
	if( top < MAX_NESTING_LEVEL) {
//		printf( "idxCurrentMenu[top] = %d\n", idxCurrentMenu[top]);
		MenuItem (*submenu)[] = (*currentMenu)[idxCurrentMenu[top]].submenu;
		if( submenu != NULL) {
			top++;
			idxCurrentMenu[top] = 0;
			currentMenu = submenu;
			//printf( "top=%d\n", top);
		}
	}
	//printf( "currentMenu = %p\n", currentMenu);
	//printf( "&menuCalefaccion = %p\n", &menuCalefaccion);

	processKey( KEY_INITIALIZE);
	//this->print();
}
void Menu::moveBackward()
{
	if( top > 0) {
		top--;
		currentMenu = (MenuItem (*)[])&mainMenu;
		for( int i=0 ; i<top ; i++) {
			currentMenu = (*currentMenu)[idxCurrentMenu[i]].submenu;
			printf( "currentMenu>\n");
		}
	}
	//printf( "top=%d\n", top);
	//this->print();
}
void Menu::moveUp()
{
	if( idxCurrentMenu[top] > 0) {
		idxCurrentMenu[top]--;
	}
	else {
		while( !(*currentMenu)[idxCurrentMenu[top]].isLastItem) {
			idxCurrentMenu[top]++;
		}
	}
	//this->print();
}
void Menu::moveDown()
{
	if( (*currentMenu)[idxCurrentMenu[top]].isLastItem) {
		//printf( "idxCurrentMenu[top] = 0\n");
		idxCurrentMenu[top] = 0;
	}
	else {
		idxCurrentMenu[top]++;
		//printf( "idxCurrentMenu[top] = %d\n", idxCurrentMenu[top]);
	}
	//this->print();
}
void Menu::doAction()
{
	tMenuAction action = (*currentMenu)[idxCurrentMenu[top]].action;
	if( action != NULL) {
		action();
		this->reset();
		//this->print();
	}
}


typedef void (Menu::*tMenuMethod)();

tMenuMethod menuProcessKeys[] = {
	NULL,
	&Menu::moveUp,
	&Menu::moveDown,
	&Menu::moveForward,
	&Menu::moveBackward,
	&Menu::doAction,
	&Menu::print,
	&Menu::print,
	&Menu::print
};

void Menu::processKey( char key)
{
	tMenuProcessKey processKey = (*currentMenu)[idxCurrentMenu[top]].processKey;
	if( processKey != NULL) {
		processKey( key);
	}
	else {
		if( (menuProcessKeys[key]) != NULL) {
			(menu.*menuProcessKeys[key])();
		}
	}
	this->print();
}

void Menu::updateEventually()
{
	long timeSinceLastPrint = millis() - timestampMenuPrinted;
//printf( "timeSinceLastPrint=%ld\n", timeSinceLastPrint);
	if( timeSinceLastPrint > TIMEOUT_MENU) {
		print();
	}
}

Menu menu;
/*
int main( int argc, char* argv[])
{
    menu.print();
    menu.moveDown();
    menu.moveDown();
    menu.moveDown();
    menu.moveDown();
    menu.moveDown();
    menu.moveDown();
    menu.moveForward();
    menu.moveForward();
    menu.moveBackward();
    menu.moveBackward();
    //menu.print();
}
*/
